

var express = require('express');

var router = express.Router();

var { Mvs, Users, Prouser, Tiwen,Advice } = require('../utils/module');


var { createToken, checkToken } = require("../utils/token")

router.get('/test', (req, res) => {
    res.json({
        code: 200,
        msg: '路由创建成功'
    })
})


router.get('/movie', (req, res) => {
    var limit = req.query.limit * 1 || 0;
    Mvs.find({}, { _id: 0 })
        .limit(limit)
        .sort({ _id: -1 })
        .then(data => {
            res.json({
                code: 200,
                msg: '电影数据请求成功',
                data
            })
        })
})


router.post('/login', (req, res) => {
    var body = req.body;
    var { username, password } = body;
    // console.log(body);
    Users.findOne({
        username: body.username,
    }).then(data => {
        // console.log(data);

        if (data) { //如果用户输入的用户名存在就判断密码是否相等
            if (data.password == body.password) {
                res.json({
                    code: 200,
                    msg: '登录成功',
                    data
                })
            }

        } else {
            res.json({
                code: 0,
                msg: '用户名或密码错误',

            })
        }
    })
})




router.get('/gettoken', (req, res) => [
    res.json({
        code: 200,
        type: 1,
        msg: '获得token成功',
        token: "wh22222"
    })
])



//疫情管理系统的登录
router.post("/signin", (req, res) => {
    var body = req.body;
    // console.log(body);
    var { mobile, password } = body
    Prouser.findOne({
        mobile: mobile
    }).then(result => {
        // console.log(result);
        if (result) {
            if (result.password == password) {
                var token = createToken({
                    mobile: mobile,
                    password: password,
                    roleid: result.roleid,
                    username: result.username
                })
                res.json({
                    code: 200,
                    type: 1,
                    msg: "登录成功",
                    token
                })
            } else {
                res.json({
                    code: 200,
                    type: 0,
                    msg: "登录失败，账号或密码不正确"
                })
            }
        } else {
            res.json({
                code: 200,
                type: 0,
                msg: "登录失败,用户名和密码不匹配"
            })
        }
    })

})



//通过token获取登录的用户信息
router.post("/getuserinfo", (req, res) => {
    checkToken(req, res, (data) => {
        var { mobile, password } = data;
        // console.log(mobile,password);
        Prouser.findOne({
            mobile,
        }).then(result => {
            res.json({
                code: 200,
                type: 1,
                msg: '获取用户信息成功',
                result
            })
        })
    })

})


//添加用户  根据post提交的信息来判断是否能添加用户
router.post('/adduser', (req, res) => {

    checkToken(req, res, (result) => {
        var { mobile, roleid } = result;
        var body = req.body;
        if (body.roleid > roleid) {
            res.json({
                code: 403,
                type: 0,
                msg: '权限不够，无法添加此用户'
            })
        } else {
            Prouser.findOne({
                mobile: body.mobile
            }).then(data => {
                if (data) {
                    //如果添加的用户已存在，就提示管理员
                    res.json({
                        code: 402,
                        type: 0,
                        msg: '手机号码已存在，请确认用户数据'
                    })
                } else {
                    body.time = new Date();
                    Prouser.insertMany(body)
                        .then(result => {
                            res.json({
                                code: 200,
                                type: 1,
                                msg: '添加用户成功',
                                result
                            })
                        })

                }
            })
        }
    })

})


//查询用户数据，渲染用户列表
router.post('/getalluser', (req, res) => {
    checkToken(req, res, () => {
        //
        Prouser.find()
            .sort({ _id: -1 })
            .then(result => {
                res.json({
                    code: 200,
                    type: 1,
                    msg: '获取到所有用户信息成功',
                    result
                })
            })
    })
})

//根据_id 删除用户
router.post('/deluser', (req, res) => {
    checkToken(req, res, (result) => {
        Prouser.remove({
            _id: req.body._id
        }).then(data => {
            res.json({
                code: 200,
                msg: '用户删除成功',
                data,
                type: 1
            })
        }).catch(err => {
            res.json({
                code: 500,
                msg: '服务器异常',
                err,
                type: 0
            })
        })
    })
})


//根据_id 修改用户信息
router.post("/updateuserone", (req, res) => {
    checkToken(req, res, (data) => {
        var body = { ...req.body, time: new Date() }
        Prouser.updateMany({
            _id: req.body._id
        }, {
            $set: body
        }).then(result => {
            res.json({
                code: 200,
                msg: '修改用户成功',
                type: 1,
                result
            })
        }).catch(err => {
            res.json({
                code: 500,
                msg: "服务器异常",
                err,
                type: 0
            })
        })
    })
})


//提交体温记录
router.post('/addtiwen', (req, res) => {
    checkToken(req, res, ({ mobile, roleid }) => {
        var { tiwen } = req.body;
        //先根据token查询用户的信息，然后把用户的信息和体温等需要登记的信息添加到数据库里
        Prouser.findOne({
            mobile,
        }).then(userinfo => { //获取到用户信息，把用户提交的体温等信息添加到数据库
            Tiwen.insertMany({
                time: new Date(),
                mobile,
                roleid,
                username: userinfo.username,
                tiwen,
                ischeck: "1",
                is_yin: '1',
            }).then(data => { //如果提交成功就查询此用户所有的体温记录信息，返回给前端
                Tiwen.find({
                    mobile
                }).then(result => {//查询成功就把数据返回给前端
                    res.json({
                        code: 200,
                        type: 1,
                        msg: '成功添加体温信息并查询到该用户的体温记录',
                        result
                    })
                }).catch(err => {
                    res.json({
                        code: 500,
                        type: 0,
                        err,
                        msg: '服务器异常'
                    })
                })
            })

        })
    })
})

//获取登录用户的所有体温信息
router.post('/getusertiwen',(req,res)=>{
    checkToken(req,res,({mobile,roleid})=>{
        Tiwen.find({
            mobile
        })
        .sort({_id:-1})
        .then(result => {//查询成功就把数据返回给前端
            res.json({
                code: 200,
                type: 1,
                msg: '成功查询到该用户的体温记录',
                result
            })
        }).catch(err => {
            res.json({
                code: 500,
                type: 0,
                err,
                msg: '服务器异常'
            })
        })
    })
})


//根据_id 删除一条体温信息
router.post("/delonetiwen",(req,res)=>{
    checkToken(req,res,()=>{
        var {_id} = req.body
        Tiwen.remove({
            _id
        }).then(result=>{
            res.json({
                code:200,
                type:1,
                result,
                msg:'删除成功'
            })
        }).catch(err=>{
            res.json({
                code:500,
                type:0,
                err,
                msg:'服务器异常'
            })
        })
    })
})

// 根据_id 修改一条数据
router.post('/updateonetiwen',(req,res)=>{
    checkToken(req,res,({mobile,roleid,username})=>{
        var body = {...req.body,time:new Date()}
        Tiwen.updateMany({
            _id:req.body._id
        },{
            $set:body
        }).then(result=>{
            res.json({
                code:200,
                type:1,
                result,
                msg:'修改体温信息成功'
            })
            .catch(err=>{
                res.json({
                    code:500,
                    type:0,
                    err,
                    msg:'服务器异常'
                })
            })
        })

    })
})

// 根据用户传来的数据更新用户信息，根据mobile来查询用户的所有体温信息
router.post('/updatecheck',(req,res)=>{
    checkToken(req,res,({mobile})=>{
        Tiwen.updateMany({
            _id:req.body._id
        },{
            $set:{
                ischeck:req.body.ischeck
            }
        })
        .then(result=>{
            res.json({
                code:200,
                type:1,
                result,
                msg:'检测结果修改成功'
            })
        })
        .catch(err=>{
            res.json({
                code:500,
                type:0,
                err,
                msg:'服务器异常'
            })
        })
    })
})

//根据用传来的_id 来修改用户的核酸检测结果
router.post('/updatecheckresult',(req,res)=>{
    checkToken(req,res,({mobile})=>{
        Tiwen.updateMany({
            _id: req.body._id
        },{
            $set:{
                is_yin:req.body.is_yin
            }
        })
        .then(result=>{
            res.json({
                code:200,
                type:1,
                result,
                msg:'修改核酸检测结果成功'
            })
        })
        .catch(err=>{
            res.json({
                code:500,
                type:0,
                result,
                msg:'服务器异常'
            })
        })
    })
})

//根据用户传来的数据，把用户意见的相关信息添加到意见表里
router.post('/adduseradvice',(req,res)=>{
    checkToken(req,res,({mobile,roleid,username})=>{
        var body = {...req.body,time:new Date(),mobile,username,roleid}
        Advice.insertMany({
            ...body
        })
        .then(result=>{
            res.json({
                code:200,
                type:1,
                result,
                msg:'意见提交成功'
            })
        })
        .catch(err=>{
            res.json({
                code:500,
                type:0,
                err,
                msg:'服务器异常'
            })
        })
    })
})


//获取意见列表
router.post('/getalladvice',(req,res)=>{
    checkToken(req,res,({mobile})=>{
        Advice.find()
        .sort({_id:-1})
        .then(result=>{
            res.json({
                code:200,
                type:1,
                result,
                msg:'意见列表信息获取成功'
            })
        })
        .catch(err=>{
            res.json({
                code:500,
                type:0,
                err,
                msg:'服务器异常'
            })
        })
    })
})

//根据 _id  删除意见信息
router.post('/deloneadvice',(req,res)=>{
    checkToken(req,res,({mobile})=>{
        Advice.remove({
            _id:req.body._id
        })
        .then(result=>{
            res.json({
                code:200,
                type:1,
                result,
                msg:'意见信息删除成功'
            })
        })
        .catch(err=>{
            res.json({
                code:500,
                type:0,
                err,
                msg:'服务器异常'
            })
        })
    })
    
})

//获取意见
router.post('/getadvicebyid',(req,res)=>{
    checkToken(req,res,({mobile})=>{
        var obj = {
            _id:req.body._id
        }
        Advice.findOne(obj,{})
        .then(result=>{
            res.json({
                code:200,
                msg:"查询成功",
                result,
                type:1
            })    
        }).catch(err=>{
            res.json({
                code:500,
                msg:"服务器异常",
                err,
                type:0
            })
        })
    })
})


//根据用户传来的数据，更新用户意见的相关信息
router.post('/updateadvice',(req,res)=>{
    checkToken(req,res,({mobile})=>{
        var obj = {
            _id: req.body._id
        }
        var body = {...req.body,time:new Date()}
        Advice.updateMany(obj,{
            $set:body
        })
        .then(result=>{
            res.json({
                code:200,
                type:1,
                result,
                msg:'意见信息修改成功'
            })
        })
        .catch(err=>{
            res.json({
                code:500,
                type:0,
                err,
                msg:'服务器异常'
            })
        })
    })
})

module.exports = router;